      <script>
      (function () {
        "use strict";

        // ═══════════════════════════════════════════════════════════
        // تنظیمات قابل شخصی‌سازی کره
        // ═══════════════════════════════════════════════════════════
        const NS_CONFIG = {
          // اندازه کانتینر اصلی (پیکسل)
          containerSize: 600,

          // شعاع کره (پیکسل) - هرچه بزرگتر، تصاویر دورتر از هم
          sphereRadius: 200,

          // حساسیت درگ کردن (0.1 تا 2) - عدد بالاتر = حرکت سریعتر
          dragSensitivity: 0.8,

          // کاهش سرعت حرکت (0.9 تا 0.99) - عدد بالاتر = حرکت طولانی‌تر
          momentumDecay: 0.96,

          // حداکثر سرعت چرخش (پیکسل در فریم)
          maxRotationSpeed: 6,

          // مقیاس پایه تصاویر (0.1 تا 0.3) - اندازه تصاویر روی کره
          baseImageScale: 0.15,

          // فعال/غیرفعال کردن چرخش خودکار
          autoRotate: true,

          // سرعت چرخش خودکار (0.1 تا 1) - فقط اگر autoRotate فعال باشد
          autoRotateSpeed: 0.2,
        };

        // تنظیمات واکنش‌گرایی برای اندازه‌های صفحه نمایش کوچکتر
        if (window.innerWidth <= 768) {
          NS_CONFIG.containerSize = 500;
          NS_CONFIG.sphereRadius = 180;
        }
        if (window.innerWidth <= 480) {
          NS_CONFIG.containerSize = 320;
          NS_CONFIG.sphereRadius = 120;
        }

        // ═══════════════════════════════════════════════════════════
        // متغیرهای داخلی برنامه
        // ═══════════════════════════════════════════════════════════
        let nsImages = [];
        let nsPositions = [];
        let nsRotation = { x: 15, y: 15 };
        let nsVelocity = { x: 0, y: 0 };
        let nsIsDragging = false;
        let nsLastMouse = { x: 0, y: 0 };
        let nsAnimationId = null;
        let nsCurrentModalIndex = 0;

        const nsSphereContainer = document.getElementById("nsSphereContainer");
        const nsSphereWorld = document.getElementById("nsSphereWorld");
        const nsModalOverlay = document.getElementById("nsModalOverlay");
        const nsModalContent = document.getElementById("nsModalContent");
        const nsModalClose = document.getElementById("nsModalClose");
        const nsModalImage = document.getElementById("nsModalImage");
        const nsModalTitle = document.getElementById("nsModalTitle");
        const nsModalDescription =
          document.getElementById("nsModalDescription");
        const nsModalCounter = document.getElementById("nsModalCounter");
        const nsModalPrev = document.getElementById("nsModalPrev");
        const nsModalNext = document.getElementById("nsModalNext");

        function nsInit() {
          const nsImageDataElement = document.getElementById("nsImageData");
          const nsBaseImages = JSON.parse(nsImageDataElement.textContent);

          for (let i = 0; i < 60; i++) {
            const nsBaseIndex = i % nsBaseImages.length;
            nsImages.push({
              ...nsBaseImages[nsBaseIndex],
              id: "ns-img-" + (i + 1),
            });
          }

          nsGeneratePositions();
          nsCreateImageElements();
          nsStartAnimation();
          nsAttachEvents();
        }

        function nsGeneratePositions() {
          const nsGoldenRatio = (1 + Math.sqrt(5)) / 2;
          const nsAngleIncrement = (2 * Math.PI) / nsGoldenRatio;

          for (let i = 0; i < nsImages.length; i++) {
            const nsT = i / nsImages.length;
            const nsInclination = Math.acos(1 - 2 * nsT);
            const nsAzimuth = nsAngleIncrement * i;

            let nsPhi = nsInclination * (180 / Math.PI);
            let nsTheta = (nsAzimuth * (180 / Math.PI)) % 360;

            const nsPoleBonus = Math.pow(Math.abs(nsPhi - 90) / 90, 0.6) * 35;
            if (nsPhi < 90) {
              nsPhi = Math.max(5, nsPhi - nsPoleBonus);
            } else {
              nsPhi = Math.min(175, nsPhi + nsPoleBonus);
            }

            nsPhi = 15 + (nsPhi / 180) * 150;

            const nsRandomOffset = (Math.random() - 0.5) * 20;
            nsTheta = (nsTheta + nsRandomOffset) % 360;
            nsPhi = Math.max(
              0,
              Math.min(180, nsPhi + (Math.random() - 0.5) * 10)
            );

            nsPositions.push({
              theta: nsTheta,
              phi: nsPhi,
              radius: NS_CONFIG.sphereRadius,
            });
          }
        }
        function nsCreateImageElements() {
  nsImages.forEach((nsImg, nsIndex) => {
    const nsDiv = document.createElement("div");
    nsDiv.className = "ns-sphere-image";
    nsDiv.dataset.index = nsIndex;

    const nsImgEl = document.createElement("img");
    nsImgEl.src = nsImg.src;
    nsImgEl.alt = nsImg.alt;
    nsImgEl.loading = nsIndex < 3 ? "eager" : "lazy";

    nsDiv.appendChild(nsImgEl);
    nsSphereWorld.appendChild(nsDiv);

    // رویداد کلیک برای دسکتاپ
    nsDiv.addEventListener("click", function (e) {
      if (!nsIsDragging) {
        nsOpenModal(nsIndex);
      }
    });

    // رویداد تاچ برای موبایل
    nsDiv.addEventListener("touchend", function (e) {
      if (!nsIsDragging) {
        e.preventDefault();
        e.stopPropagation();
        nsOpenModal(nsIndex);
      }
    });
  });
}
        function nsUpdatePositions() {
          const nsWorldPositions = nsCalculateWorldPositions();
          const nsImageElements =
            nsSphereWorld.querySelectorAll(".ns-sphere-image");

          nsImageElements.forEach((nsEl, nsIndex) => {
            const nsPos = nsWorldPositions[nsIndex];
            if (!nsPos || !nsPos.isVisible) {
              nsEl.style.display = "none";
              return;
            }

            const nsSize =
              NS_CONFIG.containerSize * NS_CONFIG.baseImageScale * nsPos.scale;
            const nsLeft = NS_CONFIG.containerSize / 2 + nsPos.x;
            const nsTop = NS_CONFIG.containerSize / 2 + nsPos.y;

            nsEl.style.display = "block";
            nsEl.style.width = nsSize + "px";
            nsEl.style.height = nsSize + "px";
            nsEl.style.left = nsLeft + "px";
            nsEl.style.top = nsTop + "px";
            nsEl.style.opacity = nsPos.fadeOpacity;
            nsEl.style.transform = "translate(-50%, -50%)";
            nsEl.style.zIndex = nsPos.zIndex;
          });
        }

        function nsCalculateWorldPositions() {
          const nsResult = [];

          nsPositions.forEach((nsPos, nsIndex) => {
            const nsThetaRad = nsPos.theta * (Math.PI / 180);
            const nsPhiRad = nsPos.phi * (Math.PI / 180);
            const nsRotXRad = nsRotation.x * (Math.PI / 180);
            const nsRotYRad = nsRotation.y * (Math.PI / 180);

            let nsX = nsPos.radius * Math.sin(nsPhiRad) * Math.cos(nsThetaRad);
            let nsY = nsPos.radius * Math.cos(nsPhiRad);
            let nsZ = nsPos.radius * Math.sin(nsPhiRad) * Math.sin(nsThetaRad);

            const nsX1 = nsX * Math.cos(nsRotYRad) + nsZ * Math.sin(nsRotYRad);
            const nsZ1 = -nsX * Math.sin(nsRotYRad) + nsZ * Math.cos(nsRotYRad);
            nsX = nsX1;
            nsZ = nsZ1;

            const nsY2 = nsY * Math.cos(nsRotXRad) - nsZ * Math.sin(nsRotXRad);
            const nsZ2 = nsY * Math.sin(nsRotXRad) + nsZ * Math.cos(nsRotXRad);
            nsY = nsY2;
            nsZ = nsZ2;

            const nsFadeZoneStart = -10;
            const nsFadeZoneEnd = -30;
            const nsIsVisible = nsZ > nsFadeZoneEnd;

            let nsFadeOpacity = 1;
            if (nsZ <= nsFadeZoneStart) {
              nsFadeOpacity = Math.max(
                0,
                (nsZ - nsFadeZoneEnd) / (nsFadeZoneStart - nsFadeZoneEnd)
              );
            }

            const nsIsPoleImage = nsPos.phi < 30 || nsPos.phi > 150;
            const nsDistanceFromCenter = Math.sqrt(nsX * nsX + nsY * nsY);
            const nsMaxDistance = NS_CONFIG.sphereRadius;
            const nsDistanceRatio = Math.min(
              nsDistanceFromCenter / nsMaxDistance,
              1
            );
            const nsDistancePenalty = nsIsPoleImage ? 0.4 : 0.7;
            const nsCenterScale = Math.max(
              0.3,
              1 - nsDistanceRatio * nsDistancePenalty
            );
            const nsDepthScale =
              (nsZ + NS_CONFIG.sphereRadius) / (2 * NS_CONFIG.sphereRadius);
            const nsScale =
              nsCenterScale * Math.max(0.5, 0.8 + nsDepthScale * 0.3);

            nsResult.push({
              x: nsX,
              y: nsY,
              z: nsZ,
              scale: nsScale,
              zIndex: Math.round(1000 + nsZ),
              isVisible: nsIsVisible,
              fadeOpacity: nsFadeOpacity,
            });
          });

          return nsResult;
        }

        function nsAnimate() {
          if (!nsIsDragging) {
            nsVelocity.x *= NS_CONFIG.momentumDecay;
            nsVelocity.y *= NS_CONFIG.momentumDecay;

            if (NS_CONFIG.autoRotate) {
              nsRotation.y += NS_CONFIG.autoRotateSpeed;
            }

            nsRotation.x = nsNormalizeAngle(
              nsRotation.x + nsClamp(nsVelocity.x)
            );
            nsRotation.y = nsNormalizeAngle(
              nsRotation.y + nsClamp(nsVelocity.y)
            );

            if (
              Math.abs(nsVelocity.x) < 0.01 &&
              Math.abs(nsVelocity.y) < 0.01 &&
              !NS_CONFIG.autoRotate
            ) {
              nsVelocity.x = 0;
              nsVelocity.y = 0;
            }
          }

          nsUpdatePositions();
          nsAnimationId = requestAnimationFrame(nsAnimate);
        }

        function nsStartAnimation() {
          if (nsAnimationId) cancelAnimationFrame(nsAnimationId);
          nsAnimationId = requestAnimationFrame(nsAnimate);
        }

        function nsNormalizeAngle(nsAngle) {
          while (nsAngle > 180) nsAngle -= 360;
          while (nsAngle < -180) nsAngle += 360;
          return nsAngle;
        }

        function nsClamp(nsValue) {
          return Math.max(
            -NS_CONFIG.maxRotationSpeed,
            Math.min(NS_CONFIG.maxRotationSpeed, nsValue)
          );
        }
        function nsAttachEvents() {
  let nsHasMoved = false;

  nsSphereContainer.addEventListener("mousedown", function (e) {
    e.preventDefault();
    nsIsDragging = true;
    nsVelocity.x = 0;
    nsVelocity.y = 0;
    nsLastMouse.x = e.clientX;
    nsLastMouse.y = e.clientY;
  });

  document.addEventListener("mousemove", function (e) {
    if (!nsIsDragging) return;

    const nsDeltaX = e.clientX - nsLastMouse.x;
    const nsDeltaY = e.clientY - nsLastMouse.y;

    const nsRotDeltaX = -nsDeltaY * NS_CONFIG.dragSensitivity;
    const nsRotDeltaY = nsDeltaX * NS_CONFIG.dragSensitivity;

    nsRotation.x = nsNormalizeAngle(
      nsRotation.x + nsClamp(nsRotDeltaX)
    );
    nsRotation.y = nsNormalizeAngle(
      nsRotation.y + nsClamp(nsRotDeltaY)
    );

    nsVelocity.x = nsClamp(nsRotDeltaX);
    nsVelocity.y = nsClamp(nsRotDeltaY);

    nsLastMouse.x = e.clientX;
    nsLastMouse.y = e.clientY;
  });

  document.addEventListener("mouseup", function () {
    nsIsDragging = false;
  });

  nsSphereContainer.addEventListener("touchstart", function (e) {
    const nsTouch = e.touches[0];
    nsIsDragging = true;
    nsHasMoved = false; // ریست کردن
    nsVelocity.x = 0;
    nsVelocity.y = 0;
    nsLastMouse.x = nsTouch.clientX;
    nsLastMouse.y = nsTouch.clientY;
  });

  document.addEventListener(
    "touchmove",
    function (e) {
      if (!nsIsDragging) return;

      const nsTouch = e.touches[0];
      const nsDeltaX = nsTouch.clientX - nsLastMouse.x;
      const nsDeltaY = nsTouch.clientY - nsLastMouse.y;

      // اگر حرکت بیشتر از 5 پیکسل بود، به عنوان درگ حساب می‌شود
      if (Math.abs(nsDeltaX) > 5 || Math.abs(nsDeltaY) > 5) {
        nsHasMoved = true;
        e.preventDefault();
      }

      const nsRotDeltaX = -nsDeltaY * NS_CONFIG.dragSensitivity;
      const nsRotDeltaY = nsDeltaX * NS_CONFIG.dragSensitivity;

      nsRotation.x = nsNormalizeAngle(
        nsRotation.x + nsClamp(nsRotDeltaX)
      );
      nsRotation.y = nsNormalizeAngle(
        nsRotation.y + nsClamp(nsRotDeltaY)
      );

      nsVelocity.x = nsClamp(nsRotDeltaX);
      nsVelocity.y = nsClamp(nsRotDeltaY);

      nsLastMouse.x = nsTouch.clientX;
      nsLastMouse.y = nsTouch.clientY;
    },
    { passive: false }
  );

  document.addEventListener("touchend", function () {
    nsIsDragging = false;
  });

  nsModalOverlay.addEventListener("click", nsCloseModal);
  nsModalContent.addEventListener("click", function (e) {
    e.stopPropagation();
  });
  nsModalClose.addEventListener("click", nsCloseModal);

  nsModalPrev.addEventListener("click", function () {
    nsShowPrevImage();
  });

  nsModalNext.addEventListener("click", function () {
    nsShowNextImage();
  });

  document.addEventListener("keydown", function (e) {
    if (!nsModalOverlay.classList.contains("ns-active")) return;

    if (e.key === "ArrowLeft" || e.key === "ArrowRight") {
      e.preventDefault();
    }

    if (e.key === "ArrowLeft") {
      nsShowPrevImage();
    } else if (e.key === "ArrowRight") {
      nsShowNextImage();
    } else if (e.key === "Escape") {
      nsCloseModal();
    }
  });
}
        function nsOpenModal(nsIndex) {
          nsCurrentModalIndex = nsIndex;
          nsUpdateModalContent();
          nsModalOverlay.classList.add("ns-active");
        }

        function nsUpdateModalContent() {
          const nsImg = nsImages[nsCurrentModalIndex];
          nsModalImage.src = nsImg.src;
          nsModalImage.alt = nsImg.alt;
          nsModalTitle.textContent = nsImg.title || "";
          nsModalDescription.textContent = nsImg.description || "";
          nsModalCounter.textContent =
            nsCurrentModalIndex + 1 + " / " + nsImages.length;
        }

        function nsShowPrevImage() {
          nsCurrentModalIndex =
            (nsCurrentModalIndex - 1 + nsImages.length) % nsImages.length;
          nsUpdateModalContent();
        }

        function nsShowNextImage() {
          nsCurrentModalIndex = (nsCurrentModalIndex + 1) % nsImages.length;
          nsUpdateModalContent();
        }

        function nsCloseModal() {
          nsModalOverlay.classList.remove("ns-active");
        }

        nsInit();
      })();
    </script>